package com.csap.framework.oauth2.server.service;

import cn.dev33.satoken.LoginUtil;
import com.csap.framework.annotation.apidoc.Description;
import com.csap.framework.oauth2.UserInfo;
import com.csap.framework.oauth2.UserInfoStoreService;
import com.csap.framework.oauth2.server.entity.UserInfoEntity;
import com.csap.framework.oauth2.server.model.UserInfoModel;
import com.csap.framework.util.Assert;
import com.csap.framework.util.StringUtil;
import com.csap.framework.util.exception.ExceptionUtils;
import com.csap.mybatisplus.extension.service.BaseCsapService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Map;

/**
 * <p>
 * 用户信息表
 * </p>
 *
 * @author yangchengfu
 * @dateTime 2021-07-25 23:51:30
 */
@Description(value = "用户信息表Service")
public interface UserInfoService extends BaseCsapService<UserInfoEntity, UserInfoModel, String>, UserInfoStoreService {
    Logger logs = LoggerFactory.getLogger(UserInfoService.class);

    /**
     * 根据登录的ID获取用户信息
     *
     * @param loginId 登录的ID
     * @param time    过期时间
     * @return 用户信息
     */
    default UserInfo userInfo(Object loginId, Long time) {
        return userInfo(loginId, time, Boolean.FALSE);
    }

    /**
     * 删除用户信息
     *
     * @param loginId 登录标识
     */
    default void removeUserInfo(Object loginId) {
        removeStore(LoginUtil.getInstance().cachekey(loginId), USERINFO);
    }

    /**
     * 删除缓存
     *
     * @param loginId 登录id
     */
    default void removeCache(Object loginId) {
        getRedisUtil().del(LoginUtil.getInstance().cachekey(loginId));
    }

    /**
     * 根据登录的ID获取用户信息
     *
     * @param loginId 登录的ID
     * @param time    过期时间
     * @param clear   是否清除
     * @return 用户信息
     */
    UserInfo userInfo(Object loginId, Long time, Boolean clear);

    /**
     * 获取用户角色列表
     *
     * @param userId 用户ID
     * @param time   过期时间
     * @param clear  是否清除
     * @return 角色列表
     */
    List<Long> roleList(String userId, Long time, Boolean clear);

    /**
     * 获取角色和权限
     *
     * @param userId   用户id
     * @param userInfo 用户信息
     * @param time     缓存时间
     */
    void rolePermissions(String userId, UserInfo userInfo, Long time);

    /**
     * 删除角色信息
     *
     * @param loginId 登录标识
     */
    default void removeRole(Object loginId) {
        removeStore(LoginUtil.getInstance().cachekey(loginId), ROLE);
    }

    /**
     * 获取用户角色列表
     *
     * @param userId 用户ID
     * @param time   过期时间
     * @return 角色列表
     */
    default List<Long> roleList(String userId, Long time) {
        return roleList(userId, time, Boolean.FALSE);
    }

    /**
     * 获取用户属性列表
     *
     * @param userId 用户ID
     * @param time   过期时间
     * @return 用户属性
     */
    default Map<String, List<String>> userAttribute(String userId, Long time) {
        return userAttribute(userId, time, Boolean.FALSE);
    }

    /**
     * 删除用户属性
     *
     * @param loginId 登录标识
     */
    default void removeUserAttribute(Object loginId) {
        removeStore(LoginUtil.getInstance().cachekey(loginId), USER_ATTRIBUTE);
    }

    /**
     * 获取用户属性列表
     *
     * @param userId 用户ID
     * @param time   过期时间
     * @param clear  是否清除
     * @return 用户属性
     */
    Map<String, List<String>> userAttribute(String userId, Long time, Boolean clear);


    /**
     * 删除用户权限
     *
     * @param loginId 登录ID
     */
    default void removePermissions(Object loginId) {
        removeStore(LoginUtil.getInstance().cachekey(loginId), PERMISSIONS);
    }

    /**
     * 获取用户权限列表
     *
     * @param userId 用户ID
     * @param time   过期时间
     * @param clear  是否清除
     * @return 权限列表
     */
    List<String> permissionsList(String userId, Long time, Boolean clear);

    /**
     * 修改用户名或者手机号，验证是否存在
     *
     * @param updateRequest 修改的信息
     */
    default void validateUpdateUserName(UserInfoModel updateRequest) {
        if (StringUtil.isNotEmpty(updateRequest.getUserName())) {
            lambdaQuery()
                    .select(UserInfoEntity::getUserId)
                    .eq(UserInfoEntity::getPlatform, LoginUtil.platform())
                    .eq(UserInfoEntity::getUserType, LoginUtil.userType())
                    .eq(UserInfoEntity::getUserName, updateRequest.getUserName())
                    .oneOptional()
                    .isNotNullConditionThrow(i -> !i.getUserId().equals(updateRequest.getUserId()), () -> {
                        logs.error("userId:{}", updateRequest.getUserId());
                        return ExceptionUtils.mpe("用户名已存在");
                    });
        }
        if (StringUtil.isNotEmpty(updateRequest.getMobile())) {
            lambdaQuery()
                    .select(UserInfoEntity::getUserId)
                    .eq(UserInfoEntity::getPlatform, LoginUtil.platform())
                    .eq(UserInfoEntity::getUserType, LoginUtil.userType())
                    .eq(UserInfoEntity::getMobile, updateRequest.getMobile())
                    .oneOptional()
                    .isNotNullConditionThrow(i -> !i.getUserId().equals(updateRequest.getUserId()), () -> ExceptionUtils.mpe("手机号已存在"));

        }
    }

    /**
     * 根据登录id获取平台id
     *
     * @param loginId 登录id
     * @return 结果
     */
    default String platform(String loginId) {
        Assert.notEmpty(loginId, "用户id不能为空");
        return lambdaQuery()
                .select(UserInfoEntity::getPlatform)
                .eq(UserInfoEntity::getUserId, loginId)
                .oneOptional()
                .isNullThrow(() -> ExceptionUtils.mpe("用户不存在"))
                .get()
                .getPlatform();
    }

}
